์ต์ ์น ์ ํ๋ฆฌ์ผ์ด์ ์์ ํจ์จ์ ์ธ ๋ฐ์ดํฐ ์ฒ๋ฆฌ๋ฅผ ์ํด ์น ์คํธ๋ฆผ์ ๊ฐ๋ ฅํ ๊ธฐ๋ฅ์ ํ์ฉํด ๋ณด์ธ์. ์ฑ๋ฅ์ ๊ฐ์ ํ๊ณ , ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ ์ค์ด๋ฉฐ, ๋ฐ์ํ ์ฌ์ฉ์ ๊ฒฝํ์ ๋ง๋๋ ๋ฐฉ๋ฒ์ ๋ฐฐ์ธ ์ ์์ต๋๋ค.
์น ์คํธ๋ฆผ: ์ต์ ์ ํ๋ฆฌ์ผ์ด์ ์ ์ํ ํจ์จ์ ์ธ ๋ฐ์ดํฐ ์ฒ๋ฆฌ
๋์์์ด ์งํํ๋ ์น ๊ฐ๋ฐ ํ๊ฒฝ์์ ํจ์จ์ ์ธ ๋ฐ์ดํฐ ์ฒ๋ฆฌ๋ ๋งค์ฐ ์ค์ํฉ๋๋ค. ์ ํ๋ฆฌ์ผ์ด์ ์ด ์ ์ ๋ ๋ฐ์ดํฐ ์ง์ฝ์ ์ผ๋ก ๋ณํจ์ ๋ฐ๋ผ, ์ ์ฒด ๋ฐ์ดํฐ์ ์ ํ ๋ฒ์ ๋ก๋ํ๊ณ ์ฒ๋ฆฌํ๋ ์ ํต์ ์ธ ๋ฐฉ์์ ์ข ์ข ์ฑ๋ฅ ๋ณ๋ชฉ ํ์๊ณผ ๋๋ฆฐ ์ฌ์ฉ์ ๊ฒฝํ์ ์ด๋ํฉ๋๋ค. ์น ์คํธ๋ฆผ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ง์ ์ผ๋ก ์ฒ๋ฆฌํ์ฌ ๋ฐ์์ฑ์ ๊ฐ์ ํ๊ณ ๋ฉ๋ชจ๋ฆฌ ์๋น๋ฅผ ์ค์ผ ์ ์๋ ๊ฐ๋ ฅํ ๋์์ ์ ๊ณตํฉ๋๋ค.
์น ์คํธ๋ฆผ์ด๋ ๋ฌด์์ธ๊ฐ?
์น ์คํธ๋ฆผ์ ๋ฐ์ดํฐ ์คํธ๋ฆผ ์์ ์ ์ํ ์ธํฐํ์ด์ค๋ฅผ ์ ๊ณตํ๋ ์ต์ ์๋ฐ์คํฌ๋ฆฝํธ API์ ๋๋ค. ์ ์ฒด ๋ฐ์ดํฐ์ ์ด ๋ก๋๋๊ธฐ๋ฅผ ๊ธฐ๋ค๋ฆฌ์ง ์๊ณ ๋ฐ์ดํฐ๊ฐ ์ฌ์ฉ ๊ฐ๋ฅํด์ง๋ ๋๋ก ์ฒญํฌ ๋จ์๋ก ์ฒ๋ฆฌํ ์ ์๊ฒ ํด์ค๋๋ค. ์ด๋ ํนํ ๋ค์๊ณผ ๊ฐ์ ๊ฒฝ์ฐ์ ์ ์ฉํฉ๋๋ค:
- ๋์ฉ๋ ํ์ผ(์: ๋น๋์ค, ์ค๋์ค ๋๋ ๋์ฉ๋ ํ ์คํธ ํ์ผ) ์ฒ๋ฆฌ.
- ๋คํธ์ํฌ ์์ฒญ์ผ๋ก๋ถํฐ์ ๋ฐ์ดํฐ๋ฅผ ์ค์๊ฐ์ผ๋ก ์ฒ๋ฆฌ.
- ๋ฐ์ดํฐ๊ฐ ๋์ฐฉํ๋ ๋๋ก ์ ๋ฐ์ดํธ๋๋ ๋ฐ์ํ ์ฌ์ฉ์ ์ธํฐํ์ด์ค ๊ตฌ์ถ.
- ๋ฐ์ดํฐ๋ฅผ ๋ ์์ ์ฒญํฌ๋ก ์ฒ๋ฆฌํ์ฌ ๋ฉ๋ชจ๋ฆฌ ์ ์ฝ.
์คํธ๋ฆผ API๋ ์ฌ๋ฌ ํต์ฌ ์ธํฐํ์ด์ค๋ก ๊ตฌ์ฑ๋ฉ๋๋ค:
- ReadableStream: ๋ฐ์ดํฐ๋ฅผ ์ฝ์ ์ ์๋ ๋ฐ์ดํฐ ์์ค๋ฅผ ๋ํ๋ ๋๋ค.
- WritableStream: ๋ฐ์ดํฐ๋ฅผ ์ธ ์ ์๋ ๋ฐ์ดํฐ ๋์์ ๋ํ๋ ๋๋ค.
- TransformStream: ReadableStream์์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด ๋ณํํ ํ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ WritableStream์ ์ฐ๋ ๋ณํ ๊ณผ์ ์ ๋ํ๋ ๋๋ค.
- ByteLengthQueuingStrategy: ์ฒญํฌ์ ํฌ๊ธฐ๋ฅผ ๋ฐ์ดํธ ๋จ์๋ก ์ธก์ ํ๋ ํ์ ์ ๋ต์ ๋๋ค.
- CountQueuingStrategy: ์ฒญํฌ์ ์๋ฅผ ์ธ๋ ํ์ ์ ๋ต์ ๋๋ค.
์น ์คํธ๋ฆผ ์ฌ์ฉ์ ์ด์
์ ํ๋ฆฌ์ผ์ด์ ์ ์น ์คํธ๋ฆผ์ ์ฑํํ๋ฉด ๋ช ๊ฐ์ง ์ค์ํ ์ด์ ์ ์ป์ ์ ์์ต๋๋ค:
์ฑ๋ฅ ํฅ์
๋ฐ์ดํฐ๋ฅผ ์ฒญํฌ ๋จ์๋ก ์ฒ๋ฆฌํจ์ผ๋ก์จ, ์น ์คํธ๋ฆผ์ ์ ์ฒด ๋ฐ์ดํฐ์ ์ด ๋ก๋๋๊ธฐ ์ ์๋ ๋ฐ์ดํฐ ์์ ์ ๋ ๋นจ๋ฆฌ ์์ํ ์ ์๊ฒ ํด์ค๋๋ค. ์ด๋ ์ ํ๋ฆฌ์ผ์ด์ ์ ์ฒด๊ฐ ์ฑ๋ฅ์ ํฌ๊ฒ ํฅ์์ํค๊ณ ๋ ๋ฐ์์ ์ธ ์ฌ์ฉ์ ๊ฒฝํ์ ์ ๊ณตํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ๋์ฉ๋ ๋น๋์ค ํ์ผ์ ์คํธ๋ฆฌ๋ฐํ๋ ๊ฒฝ์ฐ๋ฅผ ์์ํด ๋ณด์ธ์. ์น ์คํธ๋ฆผ์ ์ฌ์ฉํ๋ฉด ์ฌ์ฉ์๋ ์ ์ฒด ํ์ผ์ด ๋ค์ด๋ก๋๋๊ธฐ๋ฅผ ๊ธฐ๋ค๋ฆฌ์ง ์๊ณ ๊ฑฐ์ ์ฆ์ ๋น๋์ค๋ฅผ ์์ฒญํ ์ ์์ต๋๋ค.
๋ฉ๋ชจ๋ฆฌ ์๋น ๊ฐ์
์ ์ฒด ๋ฐ์ดํฐ์ ์ ๋ฉ๋ชจ๋ฆฌ์ ๋ก๋ํ๋ ๋์ , ์น ์คํธ๋ฆผ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ง์ ์ผ๋ก ์ฒ๋ฆฌํฉ๋๋ค. ์ด๋ ๋ฉ๋ชจ๋ฆฌ ์๋น๋ฅผ ์ค์ด๊ณ ํนํ ๋์ฉ๋ ํ์ผ์ด๋ ์ฐ์์ ์ธ ๋ฐ์ดํฐ ์คํธ๋ฆผ์ ๋ค๋ฃฐ ๋ ์ ํ๋ฆฌ์ผ์ด์ ์ ๋ ํจ์จ์ ์ผ๋ก ๋ง๋ญ๋๋ค. ์ด๋ ๋ชจ๋ฐ์ผํฐ์ด๋ ์๋ฒ ๋๋ ์์คํ ๊ณผ ๊ฐ์ด ๋ฆฌ์์ค๊ฐ ์ ํ๋ ์ฅ์น์ ๋งค์ฐ ์ค์ํฉ๋๋ค.
๋ฐ์์ฑ ํฅ์
์น ์คํธ๋ฆผ์ ์ฌ์ฉํ๋ฉด ๋ฐ์ดํฐ๊ฐ ์ฌ์ฉ ๊ฐ๋ฅํด์ง ๋๋ง๋ค ์ฌ์ฉ์ ์ธํฐํ์ด์ค๋ฅผ ์ ๋ฐ์ดํธํ์ฌ ๋ ์ํธ์์ฉ์ ์ด๊ณ ๋งค๋ ฅ์ ์ธ ๊ฒฝํ์ ์ ๊ณตํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ํ์ผ์ด ๋ค์ด๋ก๋๋๋ ๋์ ์ค์๊ฐ์ผ๋ก ์ ๋ฐ์ดํธ๋๋ ์งํ๋ฅ ํ์์ค์ ํ์ํ๊ฑฐ๋ ์ฌ์ฉ์๊ฐ ์ ๋ ฅํ๋ ๋๋ก ๊ฒ์ ๊ฒฐ๊ณผ๋ฅผ ํ์ํ ์ ์์ต๋๋ค. ์ด๋ ์ฑํ ์ ํ๋ฆฌ์ผ์ด์ ์ด๋ ๋ผ์ด๋ธ ๋์๋ณด๋์ ๊ฐ์ด ์ค์๊ฐ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋ ์ ํ๋ฆฌ์ผ์ด์ ์ ํนํ ์ค์ํฉ๋๋ค.
์ญ์๋ ฅ(Backpressure) ๊ด๋ฆฌ
์น ์คํธ๋ฆผ์ ๋ด์ฅ๋ ์ญ์๋ ฅ ๋ฉ์ปค๋์ฆ์ ์ ๊ณตํ์ฌ, ์คํธ๋ฆผ์ ์๋น์๊ฐ ๋ฐ์ดํฐ ์์ฑ ์๋๋งํผ ๋น ๋ฅด๊ฒ ์ฒ๋ฆฌํ ์ ์์ ๋ ์์ฐ์์๊ฒ ์๋๋ฅผ ๋ฆ์ถ๋ผ๊ณ ์ ํธ๋ฅผ ๋ณด๋ผ ์ ์์ต๋๋ค. ์ด๋ ์๋น์๊ฐ ๊ณผ๋ถํ๋๋ ๊ฒ์ ๋ฐฉ์งํ๊ณ ๋ฐ์ดํฐ๊ฐ ํจ์จ์ ์ด๊ณ ์์ ์ ์ผ๋ก ์ฒ๋ฆฌ๋๋๋ก ๋ณด์ฅํฉ๋๋ค. ์ด๋ ์ ๋ขฐํ ์ ์๋ ๋คํธ์ํฌ ์ฐ๊ฒฐ์์ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๊ฑฐ๋ ๋ค๋ฅธ ์๋๋ก ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ ๋ ๋งค์ฐ ์ค์ํฉ๋๋ค.
๊ตฌ์ฑ ๊ฐ๋ฅ์ฑ ๋ฐ ์ฌ์ฌ์ฉ์ฑ
์น ์คํธ๋ฆผ์ ๊ตฌ์ฑ ๊ฐ๋ฅํ๋๋ก ์ค๊ณ๋์์ผ๋ฉฐ, ์ด๋ ์ฌ๋ฌ ์คํธ๋ฆผ์ ์ฝ๊ฒ ์ฐ๊ฒฐํ์ฌ ๋ณต์กํ ๋ฐ์ดํฐ ์ฒ๋ฆฌ ํ์ดํ๋ผ์ธ์ ๋ง๋ค ์ ์์์ ์๋ฏธํฉ๋๋ค. ์ด๋ ์ฝ๋ ์ฌ์ฌ์ฉ์ฑ์ ์ด์งํ๊ณ ์ ํ๋ฆฌ์ผ์ด์ ์ ๊ตฌ์ถํ๊ณ ์ ์ง ๊ด๋ฆฌํ๊ธฐ ์ฝ๊ฒ ๋ง๋ญ๋๋ค. ์๋ฅผ ๋ค์ด, ํ์ผ์์ ๋ฐ์ดํฐ๋ฅผ ์ฝ๊ณ , ๋ค๋ฅธ ํ์์ผ๋ก ๋ณํํ ๋ค์, ๋ค๋ฅธ ํ์ผ์ ์ฐ๋ ์คํธ๋ฆผ์ ๋ง๋ค ์ ์์ต๋๋ค.
์ฌ์ฉ ์ฌ๋ก ๋ฐ ์์
์น ์คํธ๋ฆผ์ ๋ค์ฌ๋ค๋ฅํ๋ฉฐ ๋ค์ํ ์ฌ์ฉ ์ฌ๋ก์ ์ ์ฉ๋ ์ ์์ต๋๋ค. ๋ค์์ ๋ช ๊ฐ์ง ์์ ๋๋ค:
๋น๋์ค ๋ฐ ์ค๋์ค ์คํธ๋ฆฌ๋ฐ
์น ์คํธ๋ฆผ์ ๋น๋์ค ๋ฐ ์ค๋์ค ์ฝํ ์ธ ์คํธ๋ฆฌ๋ฐ์ ์ด์์ ์ ๋๋ค. ๋ฏธ๋์ด ๋ฐ์ดํฐ๋ฅผ ์ฒญํฌ ๋จ์๋ก ์ฒ๋ฆฌํจ์ผ๋ก์จ, ์ ์ฒด ํ์ผ์ด ๋ค์ด๋ก๋๋๊ธฐ ์ ์๋ ๊ฑฐ์ ์ฆ์ ์ฝํ ์ธ ์ฌ์์ ์์ํ ์ ์์ต๋๋ค. ์ด๋ ํนํ ๋๋ฆฐ ๋คํธ์ํฌ ์ฐ๊ฒฐ์์ ๋ถ๋๋ฝ๊ณ ๋ฐ์์ ์ธ ์์ฒญ ๊ฒฝํ์ ์ ๊ณตํฉ๋๋ค. ์ ํ๋ธ๋ ๋ทํ๋ฆญ์ค์ ๊ฐ์ ์ธ๊ธฐ ์๋ ๋น๋์ค ์คํธ๋ฆฌ๋ฐ ์๋น์ค๋ ์ ์ธ๊ณ์ ์ผ๋ก ์ํํ ๋น๋์ค ์ฌ์์ ์ ๊ณตํ๊ธฐ ์ํด ์ ์ฌํ ๊ธฐ์ ์ ํ์ฉํฉ๋๋ค.
์์: ReadableStream๊ณผ <video> ์์๋ฅผ ์ฌ์ฉํ ๋น๋์ค ์คํธ๋ฆฌ๋ฐ:
async function streamVideo(url, videoElement) {
const response = await fetch(url);
const reader = response.body.getReader();
while (true) {
const { done, value } = await reader.read();
if (done) {
break;
}
// Append the chunk to the video element
// (Requires a mechanism to handle appending data to the video source)
appendBuffer(videoElement, value);
}
}
๋์ฉ๋ ํ ์คํธ ํ์ผ ์ฒ๋ฆฌ
๋ก๊ทธ ํ์ผ์ด๋ CSV ํ์ผ๊ณผ ๊ฐ์ ๋์ฉ๋ ํ ์คํธ ํ์ผ์ ๋ค๋ฃฐ ๋, ์น ์คํธ๋ฆผ์ ์ฑ๋ฅ์ ํฌ๊ฒ ํฅ์์ํฌ ์ ์์ต๋๋ค. ํ์ผ์ ํ ์ค์ฉ ์ฒ๋ฆฌํจ์ผ๋ก์จ ์ ์ฒด ํ์ผ์ ๋ฉ๋ชจ๋ฆฌ์ ๋ก๋ํ๋ ๊ฒ์ ํผํ๊ณ , ๋ฉ๋ชจ๋ฆฌ ์๋น๋ฅผ ์ค์ด๋ฉฐ ๋ฐ์์ฑ์ ํฅ์์ํฌ ์ ์์ต๋๋ค. ๋ฐ์ดํฐ ๋ถ์ ํ๋ซํผ์ ์ข ์ข ๋ฐฉ๋ํ ๋ฐ์ดํฐ์ ์ ์ค์๊ฐ์ผ๋ก ์ฒ๋ฆฌํ๊ธฐ ์ํด ์คํธ๋ฆฌ๋ฐ์ ์ฌ์ฉํฉ๋๋ค.
์์: ๋์ฉ๋ ํ ์คํธ ํ์ผ์ ์ฝ๊ณ ์ค ์ ์ธ๊ธฐ:
async function countLines(file) {
const stream = file.stream();
const decoder = new TextDecoder();
let reader = stream.getReader();
let result = await reader.read();
let lines = 0;
let partialLine = '';
while (!result.done) {
let chunk = decoder.decode(result.value);
let chunkLines = (partialLine + chunk).split('\n');
partialLine = chunkLines.pop() || '';
lines += chunkLines.length;
result = await reader.read();
}
// Account for a last line if it exists
if (partialLine) {
lines++;
}
return lines;
}
์ค์๊ฐ ๋ฐ์ดํฐ ์ฒ๋ฆฌ
์น ์คํธ๋ฆผ์ ์ผ์, ๊ธ์ต ์์ฅ ๋๋ ์์ ๋ฏธ๋์ด ํผ๋์์ ์ค๋ ๋ฐ์ดํฐ์ ๊ฐ์ ์ค์๊ฐ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฐ ์ ํฉํฉ๋๋ค. ๋ฐ์ดํฐ๊ฐ ๋์ฐฉํ๋ ๋๋ก ์ฒ๋ฆฌํจ์ผ๋ก์จ ์ฌ์ฉ์์๊ฒ ์ต์ ์ ๋ณด๋ฅผ ์ ๊ณตํ๋ ๋ฐ์ํ ์ ํ๋ฆฌ์ผ์ด์ ์ ๊ตฌ์ถํ ์ ์์ต๋๋ค. ๊ธ์ต ๊ฑฐ๋ ํ๋ซํผ์ ์ค์๊ฐ ์์ฅ ๋ฐ์ดํฐ๋ฅผ ํ์ํ๊ธฐ ์ํด ์คํธ๋ฆผ์ ํฌ๊ฒ ์์กดํฉ๋๋ค.
์์: WebSocket ์คํธ๋ฆผ์ ๋ฐ์ดํฐ ์ฒ๋ฆฌ:
async function processWebSocketStream(url) {
const socket = new WebSocket(url);
socket.onmessage = async (event) => {
const stream = new ReadableStream({
start(controller) {
controller.enqueue(new TextEncoder().encode(event.data));
controller.close(); // Close stream after processing one event
}
});
const reader = stream.getReader();
let result = await reader.read();
while (!result.done) {
const decodedText = new TextDecoder().decode(result.value);
console.log('Received data:', decodedText);
result = await reader.read(); // Should only run once since the stream closes
}
};
}
์ด๋ฏธ์ง ์ฒ๋ฆฌ
์น ์คํธ๋ฆผ์ ๋ ํจ์จ์ ์ธ ์ด๋ฏธ์ง ์ฒ๋ฆฌ๋ฅผ ์ฉ์ดํ๊ฒ ํ ์ ์์ต๋๋ค. ์ด๋ฏธ์ง ๋ฐ์ดํฐ๋ฅผ ์คํธ๋ฆฌ๋ฐํจ์ผ๋ก์จ ์ ์ฒด ์ด๋ฏธ์ง๋ฅผ ๋ฉ๋ชจ๋ฆฌ์ ๋ก๋ํ์ง ์๊ณ ๋ณํ ๋ฐ ์กฐ์์ ์ํํ ์ ์์ต๋๋ค. ์ด๋ ํนํ ๋์ฉ๋ ์ด๋ฏธ์ง๋ ๋ณต์กํ ํํฐ๋ฅผ ์ ์ฉํ ๋ ์ ์ฉํฉ๋๋ค. ์จ๋ผ์ธ ์ด๋ฏธ์ง ํธ์ง๊ธฐ๋ ์ข ์ข ๋ ๋์ ์ฑ๋ฅ์ ์ํด ์คํธ๋ฆผ ๊ธฐ๋ฐ ์ฒ๋ฆฌ๋ฅผ ํ์ฉํฉ๋๋ค.
์น ์คํธ๋ฆผ ๊ตฌํ: ์ค์ฉ ๊ฐ์ด๋
์น ์คํธ๋ฆผ์ ์ฌ์ฉํ์ฌ ํ ์คํธ ํ์ผ์ ์ฝ๊ณ ๊ทธ ๋ด์ฉ์ ์ฒ๋ฆฌํ๋ ๊ฐ๋จํ ์์ ๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
- ํ์ผ๋ก๋ถํฐ ReadableStream ์์ฑํ๊ธฐ:
- ๋ฐ์ดํฐ ์ถ๋ ฅ์ ์ํ WritableStream ์์ฑํ๊ธฐ:
- ๋ฐ์ดํฐ ์ฒ๋ฆฌ๋ฅผ ์ํ TransformStream ์์ฑํ๊ธฐ:
- ์คํธ๋ฆผ ํ์ดํํ๊ธฐ:
async function processFile(file) {
const stream = file.stream();
const reader = stream.getReader();
const decoder = new TextDecoder();
let result = await reader.read();
while (!result.done) {
const chunk = decoder.decode(result.value);
console.log('Processing chunk:', chunk);
result = await reader.read();
}
console.log('File processing complete.');
}
const writableStream = new WritableStream({
write(chunk) {
console.log('Writing chunk:', chunk);
// Perform writing operations here (e.g., write to a file, send to a server)
},
close() {
console.log('WritableStream closed.');
},
abort(reason) {
console.error('WritableStream aborted:', reason);
}
});
const transformStream = new TransformStream({
transform(chunk, controller) {
const transformedChunk = chunk.toUpperCase();
controller.enqueue(transformedChunk);
}
});
// Example: Reading from a file, transforming to uppercase, and writing to the console
async function processFileAndOutput(file) {
const stream = file.stream();
const decoder = new TextDecoder();
const reader = stream.getReader();
let result = await reader.read();
while (!result.done) {
const chunk = decoder.decode(result.value);
const transformedChunk = chunk.toUpperCase();
console.log('Transformed chunk:', transformedChunk);
result = await reader.read();
}
console.log('File processing complete.');
}
์ฐธ๊ณ : `pipeTo` ๋ฉ์๋๋ ReadableStream์ WritableStream์ ์ฐ๊ฒฐํ๋ ๊ณผ์ ์ ๋จ์ํํฉ๋๋ค:
//Simplified example using pipeTo
async function processFileAndOutputPiped(file) {
const stream = file.stream();
const transformStream = new TransformStream({
transform(chunk, controller) {
const transformedChunk = new TextEncoder().encode(chunk.toUpperCase());
controller.enqueue(transformedChunk);
}
});
const writableStream = new WritableStream({
write(chunk) {
console.log('Writing chunk:', new TextDecoder().decode(chunk));
}
});
await stream
.pipeThrough(new TextDecoderStream())
.pipeThrough(transformStream)
.pipeTo(writableStream);
}
์น ์คํธ๋ฆผ ์์ ๋ชจ๋ฒ ์ฌ๋ก
์น ์คํธ๋ฆผ์ ์ด์ ์ ๊ทน๋ํํ๋ ค๋ฉด ๋ค์ ๋ชจ๋ฒ ์ฌ๋ก๋ฅผ ๊ณ ๋ คํ์ญ์์ค:
- ์ฌ๋ฐ๋ฅธ ํ์ ์ ๋ต ์ ํ: ๋ฐ์ดํฐ์ ์ฑ๊ฒฉ๊ณผ ์ ํ๋ฆฌ์ผ์ด์ ์ ์๊ตฌ ์ฌํญ์ ๋ฐ๋ผ ์ ์ ํ ํ์ ์ ๋ต(ByteLengthQueuingStrategy ๋๋ CountQueuingStrategy)์ ์ ํํ์ญ์์ค.
- ์ค๋ฅ๋ฅผ ์ ์์ ์ผ๋ก ์ฒ๋ฆฌํ๊ธฐ: ์คํธ๋ฆผ ์ฒ๋ฆฌ ์ค ์์์น ๋ชปํ ์ค๋ฅ๋ ์์ธ๋ฅผ ์ ์์ ์ผ๋ก ์ฒ๋ฆฌํ๊ธฐ ์ํด ๊ฒฌ๊ณ ํ ์ค๋ฅ ์ฒ๋ฆฌ ๋ก์ง์ ๊ตฌํํ์ญ์์ค.
- ํจ๊ณผ์ ์ผ๋ก ์ญ์๋ ฅ ๊ด๋ฆฌํ๊ธฐ: ๋ด์ฅ๋ ์ญ์๋ ฅ ๋ฉ์ปค๋์ฆ์ ํ์ฉํ์ฌ ์๋น์๊ฐ ๊ณผ๋ถํ๋๋ ๊ฒ์ ๋ฐฉ์งํ๊ณ ํจ์จ์ ์ธ ๋ฐ์ดํฐ ์ฒ๋ฆฌ๋ฅผ ๋ณด์ฅํ์ญ์์ค.
- ์ฒญํฌ ํฌ๊ธฐ ์ต์ ํ: ์ฑ๋ฅ๊ณผ ๋ฉ๋ชจ๋ฆฌ ์๋น ์ฌ์ด์ ์ต์ ์ ๊ท ํ์ ์ฐพ๊ธฐ ์ํด ๋ค์ํ ์ฒญํฌ ํฌ๊ธฐ๋ฅผ ์คํํด ๋ณด์ญ์์ค. ์์ ์ฒญํฌ๋ ๋ ์ฆ์ ์ฒ๋ฆฌ ์ค๋ฒํค๋๋ฅผ ์ ๋ฐํ ์ ์์ผ๋ฉฐ, ํฐ ์ฒญํฌ๋ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ ์ฆ๊ฐ์ํฌ ์ ์์ต๋๋ค.
- ๋ฐ์ดํฐ ๋ณํ์ TransformStream ์ฌ์ฉ: ๋ชจ๋์ ๋ฐ ์ฌ์ฌ์ฉ ๊ฐ๋ฅํ ๋ฐฉ์์ผ๋ก ๋ฐ์ดํฐ ๋ณํ์ ์ํํ๊ธฐ ์ํด TransformStream์ ํ์ฉํ์ญ์์ค.
- ํด๋ฆฌํ ๊ณ ๋ ค: ์น ์คํธ๋ฆผ์ ์ต์ ๋ธ๋ผ์ฐ์ ์์ ๋๋ฆฌ ์ง์๋์ง๋ง, ํธํ์ฑ์ ๋ณด์ฅํ๊ธฐ ์ํด ๊ตฌํ ๋ธ๋ผ์ฐ์ ์ฉ ํด๋ฆฌํ ์ฌ์ฉ์ ๊ณ ๋ คํ์ญ์์ค.
๋ธ๋ผ์ฐ์ ํธํ์ฑ
์น ์คํธ๋ฆผ์ ํฌ๋กฌ, ํ์ด์ดํญ์ค, ์ฌํ๋ฆฌ, ์ฃ์ง๋ฅผ ํฌํจํ ๋ชจ๋ ์ต์ ๋ธ๋ผ์ฐ์ ์์ ์ง์๋ฉ๋๋ค. ๊ทธ๋ฌ๋ ๊ตฌํ ๋ธ๋ผ์ฐ์ ์์๋ ํธํ์ฑ์ ์ํด ํด๋ฆฌํ์ด ํ์ํ ์ ์์ต๋๋ค. "Can I use"์ ๊ฐ์ ๋ฆฌ์์ค๋ฅผ ์ฌ์ฉํ์ฌ ๋ธ๋ผ์ฐ์ ํธํ์ฑ์ ํ์ธํ ์ ์์ต๋๋ค.
๊ฒฐ๋ก
์น ์คํธ๋ฆผ์ ์ต์ ์น ์ ํ๋ฆฌ์ผ์ด์ ์์ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋ ๊ฐ๋ ฅํ๊ณ ํจ์จ์ ์ธ ๋ฐฉ๋ฒ์ ์ ๊ณตํฉ๋๋ค. ๋ฐ์ดํฐ๋ฅผ ์ ์ง์ ์ผ๋ก ์ฒ๋ฆฌํจ์ผ๋ก์จ ์ฑ๋ฅ์ ๊ฐ์ ํ๊ณ , ๋ฉ๋ชจ๋ฆฌ ์๋น๋ฅผ ์ค์ด๋ฉฐ, ๋ ๋ฐ์์ ์ธ ์ฌ์ฉ์ ๊ฒฝํ์ ๋ง๋ค ์ ์์ต๋๋ค. ๋น๋์ค๋ฅผ ์คํธ๋ฆฌ๋ฐํ๋ , ๋์ฉ๋ ํ ์คํธ ํ์ผ์ ์ฒ๋ฆฌํ๋ , ์ค์๊ฐ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃจ๋ , ์น ์คํธ๋ฆผ์ ๊ณ ์ฑ๋ฅ์ ํ์ฅ ๊ฐ๋ฅํ ์ ํ๋ฆฌ์ผ์ด์ ์ ๊ตฌ์ถํ๋ ๋ฐ ํ์ํ ๋๊ตฌ๋ฅผ ์ ๊ณตํฉ๋๋ค.
์น ์ ํ๋ฆฌ์ผ์ด์ ์ด ๊ณ์ํด์ ์งํํ๊ณ ๋ ํจ์จ์ ์ธ ๋ฐ์ดํฐ ์ฒ๋ฆฌ๋ฅผ ์๊ตฌํจ์ ๋ฐ๋ผ, ์น ์คํธ๋ฆผ์ ๋ง์คํฐํ๋ ๊ฒ์ ์ ์ธ๊ณ ์น ๊ฐ๋ฐ์์๊ฒ ์ ์ ๋ ์ค์ํด์ง๊ณ ์์ต๋๋ค. ์ด ๊ธฐ์ ์ ๋ฐ์๋ค์์ผ๋ก์จ ๋ ๋น ๋ฅด๊ณ , ๋ ๋ฐ์์ ์ด๋ฉฐ, ๋ ์ฆ๊ฑฐ์ด ์ ํ๋ฆฌ์ผ์ด์ ์ ๋ง๋ค ์ ์์ต๋๋ค.